import {_ as _sfc_main$h} from "./SimpleDialog.vue_vue_type_script_setup_true_lang-B70uDCdu.js";
import {
    _ as _export_sfc,
    a as createElementBlock,
    a1 as createReusableTemplate,
    a2 as useCssVars,
    a3 as modelFilters,
    a4 as watchDebounced,
    b as createBaseVNode,
    c as createBlock,
    d as defineComponent,
    e as ref,
    f as computed,
    F as Fragment,
    G as api,
    g as useRouter,
    H as normalizeStyle,
    I as renderSlot,
    J as mergeModels,
    j as renderList,
    k as createCommentVNode,
    K as onMounted,
    L as withDirectives,
    m as useModel,
    n as normalizeClass,
    o as openBlock,
    p as withCtx,
    P as vModelText,
    q as createVNode,
    r as resolveComponent,
    s as _sfc_main$c,
    t as toDisplayString,
    u as unref,
    v as createTextVNode,
    y as isRef,
    z as storeToRefs
} from "./index-Dfdf_Rjk.js";
import {_ as _sfc_main$6} from "./SimpleDrawer.vue_vue_type_script_setup_true_lang-e2z4Lw6B.js";
import {_ as _sfc_main$f} from "./IconButton.vue_vue_type_script_setup_true_lang-jAwwuJ2U.js";
import {
    _ as _sfc_main$8,
    a as _sfc_main$9,
    b as _sfc_main$e
} from "./SimpleCollapse.vue_vue_type_script_setup_true_lang-rzMMFhj6.js";
import {_ as _sfc_main$d} from "./SelectGroup.vue_vue_type_script_setup_true_lang-DYRZ60Lx.js";
import {
    a as getModelPeggings,
    b as getAllTags,
    c as createModelPeggingMap,
    d as deleteModel,
    g as getModelList
} from "./model-CGDRSQW4.js";
import {u as useAppStore} from "./app-D9Ky8jTR.js";
import {_ as _sfc_main$g} from "./model-form.vue_vue_type_script_setup_true_lang-c5IznUR0.js";
import {_ as _sfc_main$7, u as useCopy} from "./useCopy-DYzvKz8A.js";
import {f as formatToDateTime, g as getHashColorFromString} from "./dateUtils-CggKSslP.js";
import {_ as _sfc_main$b} from "./SimpleInput.vue_vue_type_script_setup_true_lang-D6HMgtcH.js";
import {_ as _sfc_main$a} from "./executor-Csm15pJV.js";
import "./vue-codemirror.esm-Qc3mw6Aw.js";

const _hoisted_1$4 = {
    border: "~ base rounded",
    flex: "~ inline"
};
const _sfc_main$5 = /* @__PURE__ */ defineComponent({
    __name: "ViewType",
    props: {
        "modelValue": {
            default: "list"
        },
        "modelModifiers": {}
    },
    emits: ["update:modelValue"],
    setup(__props) {
        const modelValue = useModel(__props, "modelValue");
        return (_ctx, _cache) => {
            return openBlock(), createElementBlock("div", _hoisted_1$4, [
                createBaseVNode("button", {
                    class: normalizeClass([modelValue.value === "grid" ? "view-item-active" : "", "view-item"]),
                    onClick: _cache[0] || (_cache[0] = ($event) => modelValue.value = "grid")
                }, _cache[2] || (_cache[2] = [
                    createBaseVNode("div", {class: "i-ph:grid-four"}, null, -1),
                    createTextVNode("卡片 ")
                ]), 2),
                _cache[4] || (_cache[4] = createBaseVNode("div", {border: "l base"}, null, -1)),
                createBaseVNode("button", {
                    class: normalizeClass([modelValue.value === "list" ? "view-item-active" : "", "view-item"]),
                    onClick: _cache[1] || (_cache[1] = ($event) => modelValue.value = "list")
                }, _cache[3] || (_cache[3] = [
                    createBaseVNode("div", {class: "i-ph:list"}, null, -1),
                    createTextVNode("列表 ")
                ]), 2)
            ]);
        };
    }
});
const __unplugin_components_1 = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-d310ea60"]]);

function isArray(value) {
    return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
}

function baseToString(value) {
    if (typeof value == "string") {
        return value;
    }
    let result = value + "";
    return result == "0" && 1 / value == -Infinity ? "-0" : result;
}

function toString(value) {
    return value == null ? "" : baseToString(value);
}

function isString(value) {
    return typeof value === "string";
}

function isNumber(value) {
    return typeof value === "number";
}

function isBoolean(value) {
    return value === true || value === false || isObjectLike(value) && getTag(value) == "[object Boolean]";
}

function isObject(value) {
    return typeof value === "object";
}

function isObjectLike(value) {
    return isObject(value) && value !== null;
}

function isDefined(value) {
    return value !== void 0 && value !== null;
}

function isBlank(value) {
    return !value.trim().length;
}

function getTag(value) {
    return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
}

const INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => "Invalid value for key ".concat(key);
const PATTERN_LENGTH_TOO_LARGE = (max) => "Pattern length exceeds max of ".concat(max, ".");
const MISSING_KEY_PROPERTY = (name) => "Missing ".concat(name, " property in key");
const INVALID_KEY_WEIGHT_VALUE = (key) => "Property 'weight' in key '".concat(key, "' must be a positive integer");
const hasOwn = Object.prototype.hasOwnProperty;

class KeyStore {
    constructor(keys) {
        this._keys = [];
        this._keyMap = {};
        let totalWeight = 0;
        keys.forEach((key) => {
            let obj = createKey(key);
            this._keys.push(obj);
            this._keyMap[obj.id] = obj;
            totalWeight += obj.weight;
        });
        this._keys.forEach((key) => {
            key.weight /= totalWeight;
        });
    }

    get(keyId) {
        return this._keyMap[keyId];
    }

    keys() {
        return this._keys;
    }

    toJSON() {
        return JSON.stringify(this._keys);
    }
}

function createKey(key) {
    let path = null;
    let id = null;
    let src = null;
    let weight = 1;
    let getFn = null;
    if (isString(key) || isArray(key)) {
        src = key;
        path = createKeyPath(key);
        id = createKeyId(key);
    } else {
        if (!hasOwn.call(key, "name")) {
            throw new Error(MISSING_KEY_PROPERTY("name"));
        }
        const name = key.name;
        src = name;
        if (hasOwn.call(key, "weight")) {
            weight = key.weight;
            if (weight <= 0) {
                throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
            }
        }
        path = createKeyPath(name);
        id = createKeyId(name);
        getFn = key.getFn;
    }
    return {path, id, weight, src, getFn};
}

function createKeyPath(key) {
    return isArray(key) ? key : key.split(".");
}

function createKeyId(key) {
    return isArray(key) ? key.join(".") : key;
}

function get(obj, path) {
    let list = [];
    let arr = false;
    const deepGet = (obj2, path2, index) => {
        if (!isDefined(obj2)) {
            return;
        }
        if (!path2[index]) {
            list.push(obj2);
        } else {
            let key = path2[index];
            const value = obj2[key];
            if (!isDefined(value)) {
                return;
            }
            if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
                list.push(toString(value));
            } else if (isArray(value)) {
                arr = true;
                for (let i = 0, len = value.length; i < len; i += 1) {
                    deepGet(value[i], path2, index + 1);
                }
            } else if (path2.length) {
                deepGet(value, path2, index + 1);
            }
        }
    };
    deepGet(obj, isString(path) ? path.split(".") : path, 0);
    return arr ? list : list[0];
}

const MatchOptions = {
    // Whether the matches should be included in the result set. When `true`, each record in the result
    // set will include the indices of the matched characters.
    // These can consequently be used for highlighting purposes.
    includeMatches: false,
    // When `true`, the matching function will continue to the end of a search pattern even if
    // a perfect match has already been located in the string.
    findAllMatches: false,
    // Minimum number of characters that must be matched before a result is considered a match
    minMatchCharLength: 1
};
const BasicOptions = {
    // When `true`, the algorithm continues searching to the end of the input even if a perfect
    // match is found before the end of the same input.
    isCaseSensitive: false,
    // When `true`, the algorithm will ignore diacritics (accents) in comparisons
    ignoreDiacritics: false,
    // When true, the matching function will continue to the end of a search pattern even if
    includeScore: false,
    // List of properties that will be searched. This also supports nested properties.
    keys: [],
    // Whether to sort the result list, by score
    shouldSort: true,
    // Default sort function: sort by ascending score, ascending index
    sortFn: (a, b) => a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1
};
const FuzzyOptions = {
    // Approximately where in the text is the pattern expected to be found?
    location: 0,
    // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
    // (of both letters and location), a threshold of '1.0' would match anything.
    threshold: 0.6,
    // Determines how close the match must be to the fuzzy location (specified above).
    // An exact letter match which is 'distance' characters away from the fuzzy location
    // would score as a complete mismatch. A distance of '0' requires the match be at
    // the exact location specified, a threshold of '1000' would require a perfect match
    // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
    distance: 100
};
const AdvancedOptions = {
    // When `true`, it enables the use of unix-like search commands
    useExtendedSearch: false,
    // The get function to use when fetching an object's properties.
    // The default will search nested paths *ie foo.bar.baz*
    getFn: get,
    // When `true`, search will ignore `location` and `distance`, so it won't matter
    // where in the string the pattern appears.
    // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
    ignoreLocation: false,
    // When `true`, the calculation for the relevance score (used for sorting) will
    // ignore the field-length norm.
    // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
    ignoreFieldNorm: false,
    // The weight to determine how much field length norm effects scoring.
    fieldNormWeight: 1
};
var Config = {
    ...BasicOptions,
    ...MatchOptions,
    ...FuzzyOptions,
    ...AdvancedOptions
};
const SPACE = /[^ ]+/g;

function norm(weight = 1, mantissa = 3) {
    const cache = /* @__PURE__ */ new Map();
    const m = Math.pow(10, mantissa);
    return {
        get(value) {
            const numTokens = value.match(SPACE).length;
            if (cache.has(numTokens)) {
                return cache.get(numTokens);
            }
            const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
            const n = parseFloat(Math.round(norm2 * m) / m);
            cache.set(numTokens, n);
            return n;
        },
        clear() {
            cache.clear();
        }
    };
}

class FuseIndex {
    constructor({
                    getFn = Config.getFn,
                    fieldNormWeight = Config.fieldNormWeight
                } = {}) {
        this.norm = norm(fieldNormWeight, 3);
        this.getFn = getFn;
        this.isCreated = false;
        this.setIndexRecords();
    }

    setSources(docs = []) {
        this.docs = docs;
    }

    setIndexRecords(records = []) {
        this.records = records;
    }

    setKeys(keys = []) {
        this.keys = keys;
        this._keysMap = {};
        keys.forEach((key, idx) => {
            this._keysMap[key.id] = idx;
        });
    }

    create() {
        if (this.isCreated || !this.docs.length) {
            return;
        }
        this.isCreated = true;
        if (isString(this.docs[0])) {
            this.docs.forEach((doc, docIndex) => {
                this._addString(doc, docIndex);
            });
        } else {
            this.docs.forEach((doc, docIndex) => {
                this._addObject(doc, docIndex);
            });
        }
        this.norm.clear();
    }

    // Adds a doc to the end of the index
    add(doc) {
        const idx = this.size();
        if (isString(doc)) {
            this._addString(doc, idx);
        } else {
            this._addObject(doc, idx);
        }
    }

    // Removes the doc at the specified index of the index
    removeAt(idx) {
        this.records.splice(idx, 1);
        for (let i = idx, len = this.size(); i < len; i += 1) {
            this.records[i].i -= 1;
        }
    }

    getValueForItemAtKeyId(item, keyId) {
        return item[this._keysMap[keyId]];
    }

    size() {
        return this.records.length;
    }

    _addString(doc, docIndex) {
        if (!isDefined(doc) || isBlank(doc)) {
            return;
        }
        let record = {
            v: doc,
            i: docIndex,
            n: this.norm.get(doc)
        };
        this.records.push(record);
    }

    _addObject(doc, docIndex) {
        let record = {i: docIndex, $: {}};
        this.keys.forEach((key, keyIndex) => {
            let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
            if (!isDefined(value)) {
                return;
            }
            if (isArray(value)) {
                let subRecords = [];
                const stack = [{nestedArrIndex: -1, value}];
                while (stack.length) {
                    const {nestedArrIndex, value: value2} = stack.pop();
                    if (!isDefined(value2)) {
                        continue;
                    }
                    if (isString(value2) && !isBlank(value2)) {
                        let subRecord = {
                            v: value2,
                            i: nestedArrIndex,
                            n: this.norm.get(value2)
                        };
                        subRecords.push(subRecord);
                    } else if (isArray(value2)) {
                        value2.forEach((item, k) => {
                            stack.push({
                                nestedArrIndex: k,
                                value: item
                            });
                        });
                    } else ;
                }
                record.$[keyIndex] = subRecords;
            } else if (isString(value) && !isBlank(value)) {
                let subRecord = {
                    v: value,
                    n: this.norm.get(value)
                };
                record.$[keyIndex] = subRecord;
            }
        });
        this.records.push(record);
    }

    toJSON() {
        return {
            keys: this.keys,
            records: this.records
        };
    }
}

function createIndex(keys, docs, {getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight} = {}) {
    const myIndex = new FuseIndex({getFn, fieldNormWeight});
    myIndex.setKeys(keys.map(createKey));
    myIndex.setSources(docs);
    myIndex.create();
    return myIndex;
}

function parseIndex(data, {getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight} = {}) {
    const {keys, records} = data;
    const myIndex = new FuseIndex({getFn, fieldNormWeight});
    myIndex.setKeys(keys);
    myIndex.setIndexRecords(records);
    return myIndex;
}

function computeScore$1(pattern, {
    errors = 0,
    currentLocation = 0,
    expectedLocation = 0,
    distance = Config.distance,
    ignoreLocation = Config.ignoreLocation
} = {}) {
    const accuracy = errors / pattern.length;
    if (ignoreLocation) {
        return accuracy;
    }
    const proximity = Math.abs(expectedLocation - currentLocation);
    if (!distance) {
        return proximity ? 1 : accuracy;
    }
    return accuracy + proximity / distance;
}

function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMatchCharLength) {
    let indices = [];
    let start = -1;
    let end = -1;
    let i = 0;
    for (let len = matchmask.length; i < len; i += 1) {
        let match = matchmask[i];
        if (match && start === -1) {
            start = i;
        } else if (!match && start !== -1) {
            end = i - 1;
            if (end - start + 1 >= minMatchCharLength) {
                indices.push([start, end]);
            }
            start = -1;
        }
    }
    if (matchmask[i - 1] && i - start >= minMatchCharLength) {
        indices.push([start, i - 1]);
    }
    return indices;
}

const MAX_BITS = 32;

function search(text, pattern, patternAlphabet, {
    location = Config.location,
    distance = Config.distance,
    threshold = Config.threshold,
    findAllMatches = Config.findAllMatches,
    minMatchCharLength = Config.minMatchCharLength,
    includeMatches = Config.includeMatches,
    ignoreLocation = Config.ignoreLocation
} = {}) {
    if (pattern.length > MAX_BITS) {
        throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
    }
    const patternLen = pattern.length;
    const textLen = text.length;
    const expectedLocation = Math.max(0, Math.min(location, textLen));
    let currentThreshold = threshold;
    let bestLocation = expectedLocation;
    const computeMatches = minMatchCharLength > 1 || includeMatches;
    const matchMask = computeMatches ? Array(textLen) : [];
    let index;
    while ((index = text.indexOf(pattern, bestLocation)) > -1) {
        let score = computeScore$1(pattern, {
            currentLocation: index,
            expectedLocation,
            distance,
            ignoreLocation
        });
        currentThreshold = Math.min(score, currentThreshold);
        bestLocation = index + patternLen;
        if (computeMatches) {
            let i = 0;
            while (i < patternLen) {
                matchMask[index + i] = 1;
                i += 1;
            }
        }
    }
    bestLocation = -1;
    let lastBitArr = [];
    let finalScore = 1;
    let binMax = patternLen + textLen;
    const mask = 1 << patternLen - 1;
    for (let i = 0; i < patternLen; i += 1) {
        let binMin = 0;
        let binMid = binMax;
        while (binMin < binMid) {
            const score2 = computeScore$1(pattern, {
                errors: i,
                currentLocation: expectedLocation + binMid,
                expectedLocation,
                distance,
                ignoreLocation
            });
            if (score2 <= currentThreshold) {
                binMin = binMid;
            } else {
                binMax = binMid;
            }
            binMid = Math.floor((binMax - binMin) / 2 + binMin);
        }
        binMax = binMid;
        let start = Math.max(1, expectedLocation - binMid + 1);
        let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
        let bitArr = Array(finish + 2);
        bitArr[finish + 1] = (1 << i) - 1;
        for (let j = finish; j >= start; j -= 1) {
            let currentLocation = j - 1;
            let charMatch = patternAlphabet[text.charAt(currentLocation)];
            if (computeMatches) {
                matchMask[currentLocation] = +!!charMatch;
            }
            bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
            if (i) {
                bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
            }
            if (bitArr[j] & mask) {
                finalScore = computeScore$1(pattern, {
                    errors: i,
                    currentLocation,
                    expectedLocation,
                    distance,
                    ignoreLocation
                });
                if (finalScore <= currentThreshold) {
                    currentThreshold = finalScore;
                    bestLocation = currentLocation;
                    if (bestLocation <= expectedLocation) {
                        break;
                    }
                    start = Math.max(1, 2 * expectedLocation - bestLocation);
                }
            }
        }
        const score = computeScore$1(pattern, {
            errors: i + 1,
            currentLocation: expectedLocation,
            expectedLocation,
            distance,
            ignoreLocation
        });
        if (score > currentThreshold) {
            break;
        }
        lastBitArr = bitArr;
    }
    const result = {
        isMatch: bestLocation >= 0,
        // Count exact matches (those with a score of 0) to be "almost" exact
        score: Math.max(1e-3, finalScore)
    };
    if (computeMatches) {
        const indices = convertMaskToIndices(matchMask, minMatchCharLength);
        if (!indices.length) {
            result.isMatch = false;
        } else if (includeMatches) {
            result.indices = indices;
        }
    }
    return result;
}

function createPatternAlphabet(pattern) {
    let mask = {};
    for (let i = 0, len = pattern.length; i < len; i += 1) {
        const char = pattern.charAt(i);
        mask[char] = (mask[char] || 0) | 1 << len - i - 1;
    }
    return mask;
}

const stripDiacritics = String.prototype.normalize ? (str) => str.normalize("NFD").replace(/[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/g, "") : (str) => str;

class BitapSearch {
    constructor(pattern, {
        location = Config.location,
        threshold = Config.threshold,
        distance = Config.distance,
        includeMatches = Config.includeMatches,
        findAllMatches = Config.findAllMatches,
        minMatchCharLength = Config.minMatchCharLength,
        isCaseSensitive = Config.isCaseSensitive,
        ignoreDiacritics = Config.ignoreDiacritics,
        ignoreLocation = Config.ignoreLocation
    } = {}) {
        this.options = {
            location,
            threshold,
            distance,
            includeMatches,
            findAllMatches,
            minMatchCharLength,
            isCaseSensitive,
            ignoreDiacritics,
            ignoreLocation
        };
        pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
        pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
        this.pattern = pattern;
        this.chunks = [];
        if (!this.pattern.length) {
            return;
        }
        const addChunk = (pattern2, startIndex) => {
            this.chunks.push({
                pattern: pattern2,
                alphabet: createPatternAlphabet(pattern2),
                startIndex
            });
        };
        const len = this.pattern.length;
        if (len > MAX_BITS) {
            let i = 0;
            const remainder = len % MAX_BITS;
            const end = len - remainder;
            while (i < end) {
                addChunk(this.pattern.substr(i, MAX_BITS), i);
                i += MAX_BITS;
            }
            if (remainder) {
                const startIndex = len - MAX_BITS;
                addChunk(this.pattern.substr(startIndex), startIndex);
            }
        } else {
            addChunk(this.pattern, 0);
        }
    }

    searchIn(text) {
        const {isCaseSensitive, ignoreDiacritics, includeMatches} = this.options;
        text = isCaseSensitive ? text : text.toLowerCase();
        text = ignoreDiacritics ? stripDiacritics(text) : text;
        if (this.pattern === text) {
            let result2 = {
                isMatch: true,
                score: 0
            };
            if (includeMatches) {
                result2.indices = [[0, text.length - 1]];
            }
            return result2;
        }
        const {
            location,
            distance,
            threshold,
            findAllMatches,
            minMatchCharLength,
            ignoreLocation
        } = this.options;
        let allIndices = [];
        let totalScore = 0;
        let hasMatches = false;
        this.chunks.forEach(({pattern, alphabet, startIndex}) => {
            const {isMatch, score, indices} = search(text, pattern, alphabet, {
                location: location + startIndex,
                distance,
                threshold,
                findAllMatches,
                minMatchCharLength,
                includeMatches,
                ignoreLocation
            });
            if (isMatch) {
                hasMatches = true;
            }
            totalScore += score;
            if (isMatch && indices) {
                allIndices = [...allIndices, ...indices];
            }
        });
        let result = {
            isMatch: hasMatches,
            score: hasMatches ? totalScore / this.chunks.length : 1
        };
        if (hasMatches && includeMatches) {
            result.indices = allIndices;
        }
        return result;
    }
}

class BaseMatch {
    constructor(pattern) {
        this.pattern = pattern;
    }

    static isMultiMatch(pattern) {
        return getMatch(pattern, this.multiRegex);
    }

    static isSingleMatch(pattern) {
        return getMatch(pattern, this.singleRegex);
    }

    search() {
    }
}

function getMatch(pattern, exp) {
    const matches = pattern.match(exp);
    return matches ? matches[1] : null;
}

class ExactMatch extends BaseMatch {
    constructor(pattern) {
        super(pattern);
    }

    static get type() {
        return "exact";
    }

    static get multiRegex() {
        return /^="(.*)"$/;
    }

    static get singleRegex() {
        return /^=(.*)$/;
    }

    search(text) {
        const isMatch = text === this.pattern;
        return {
            isMatch,
            score: isMatch ? 0 : 1,
            indices: [0, this.pattern.length - 1]
        };
    }
}

class InverseExactMatch extends BaseMatch {
    constructor(pattern) {
        super(pattern);
    }

    static get type() {
        return "inverse-exact";
    }

    static get multiRegex() {
        return /^!"(.*)"$/;
    }

    static get singleRegex() {
        return /^!(.*)$/;
    }

    search(text) {
        const index = text.indexOf(this.pattern);
        const isMatch = index === -1;
        return {
            isMatch,
            score: isMatch ? 0 : 1,
            indices: [0, text.length - 1]
        };
    }
}

class PrefixExactMatch extends BaseMatch {
    constructor(pattern) {
        super(pattern);
    }

    static get type() {
        return "prefix-exact";
    }

    static get multiRegex() {
        return /^\^"(.*)"$/;
    }

    static get singleRegex() {
        return /^\^(.*)$/;
    }

    search(text) {
        const isMatch = text.startsWith(this.pattern);
        return {
            isMatch,
            score: isMatch ? 0 : 1,
            indices: [0, this.pattern.length - 1]
        };
    }
}

class InversePrefixExactMatch extends BaseMatch {
    constructor(pattern) {
        super(pattern);
    }

    static get type() {
        return "inverse-prefix-exact";
    }

    static get multiRegex() {
        return /^!\^"(.*)"$/;
    }

    static get singleRegex() {
        return /^!\^(.*)$/;
    }

    search(text) {
        const isMatch = !text.startsWith(this.pattern);
        return {
            isMatch,
            score: isMatch ? 0 : 1,
            indices: [0, text.length - 1]
        };
    }
}

class SuffixExactMatch extends BaseMatch {
    constructor(pattern) {
        super(pattern);
    }

    static get type() {
        return "suffix-exact";
    }

    static get multiRegex() {
        return /^"(.*)"\$$/;
    }

    static get singleRegex() {
        return /^(.*)\$$/;
    }

    search(text) {
        const isMatch = text.endsWith(this.pattern);
        return {
            isMatch,
            score: isMatch ? 0 : 1,
            indices: [text.length - this.pattern.length, text.length - 1]
        };
    }
}

class InverseSuffixExactMatch extends BaseMatch {
    constructor(pattern) {
        super(pattern);
    }

    static get type() {
        return "inverse-suffix-exact";
    }

    static get multiRegex() {
        return /^!"(.*)"\$$/;
    }

    static get singleRegex() {
        return /^!(.*)\$$/;
    }

    search(text) {
        const isMatch = !text.endsWith(this.pattern);
        return {
            isMatch,
            score: isMatch ? 0 : 1,
            indices: [0, text.length - 1]
        };
    }
}

class FuzzyMatch extends BaseMatch {
    constructor(pattern, {
        location = Config.location,
        threshold = Config.threshold,
        distance = Config.distance,
        includeMatches = Config.includeMatches,
        findAllMatches = Config.findAllMatches,
        minMatchCharLength = Config.minMatchCharLength,
        isCaseSensitive = Config.isCaseSensitive,
        ignoreDiacritics = Config.ignoreDiacritics,
        ignoreLocation = Config.ignoreLocation
    } = {}) {
        super(pattern);
        this._bitapSearch = new BitapSearch(pattern, {
            location,
            threshold,
            distance,
            includeMatches,
            findAllMatches,
            minMatchCharLength,
            isCaseSensitive,
            ignoreDiacritics,
            ignoreLocation
        });
    }

    static get type() {
        return "fuzzy";
    }

    static get multiRegex() {
        return /^"(.*)"$/;
    }

    static get singleRegex() {
        return /^(.*)$/;
    }

    search(text) {
        return this._bitapSearch.searchIn(text);
    }
}

class IncludeMatch extends BaseMatch {
    constructor(pattern) {
        super(pattern);
    }

    static get type() {
        return "include";
    }

    static get multiRegex() {
        return /^'"(.*)"$/;
    }

    static get singleRegex() {
        return /^'(.*)$/;
    }

    search(text) {
        let location = 0;
        let index;
        const indices = [];
        const patternLen = this.pattern.length;
        while ((index = text.indexOf(this.pattern, location)) > -1) {
            location = index + patternLen;
            indices.push([index, location - 1]);
        }
        const isMatch = !!indices.length;
        return {
            isMatch,
            score: isMatch ? 0 : 1,
            indices
        };
    }
}

const searchers = [
    ExactMatch,
    IncludeMatch,
    PrefixExactMatch,
    InversePrefixExactMatch,
    InverseSuffixExactMatch,
    SuffixExactMatch,
    InverseExactMatch,
    FuzzyMatch
];
const searchersLen = searchers.length;
const SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
const OR_TOKEN = "|";

function parseQuery(pattern, options = {}) {
    return pattern.split(OR_TOKEN).map((item) => {
        let query = item.trim().split(SPACE_RE).filter((item2) => item2 && !!item2.trim());
        let results = [];
        for (let i = 0, len = query.length; i < len; i += 1) {
            const queryItem = query[i];
            let found = false;
            let idx = -1;
            while (!found && ++idx < searchersLen) {
                const searcher = searchers[idx];
                let token = searcher.isMultiMatch(queryItem);
                if (token) {
                    results.push(new searcher(token, options));
                    found = true;
                }
            }
            if (found) {
                continue;
            }
            idx = -1;
            while (++idx < searchersLen) {
                const searcher = searchers[idx];
                let token = searcher.isSingleMatch(queryItem);
                if (token) {
                    results.push(new searcher(token, options));
                    break;
                }
            }
        }
        return results;
    });
}

const MultiMatchSet = /* @__PURE__ */ new Set([FuzzyMatch.type, IncludeMatch.type]);

class ExtendedSearch {
    constructor(pattern, {
        isCaseSensitive = Config.isCaseSensitive,
        ignoreDiacritics = Config.ignoreDiacritics,
        includeMatches = Config.includeMatches,
        minMatchCharLength = Config.minMatchCharLength,
        ignoreLocation = Config.ignoreLocation,
        findAllMatches = Config.findAllMatches,
        location = Config.location,
        threshold = Config.threshold,
        distance = Config.distance
    } = {}) {
        this.query = null;
        this.options = {
            isCaseSensitive,
            ignoreDiacritics,
            includeMatches,
            minMatchCharLength,
            findAllMatches,
            ignoreLocation,
            location,
            threshold,
            distance
        };
        pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
        pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
        this.pattern = pattern;
        this.query = parseQuery(this.pattern, this.options);
    }

    static condition(_, options) {
        return options.useExtendedSearch;
    }

    searchIn(text) {
        const query = this.query;
        if (!query) {
            return {
                isMatch: false,
                score: 1
            };
        }
        const {includeMatches, isCaseSensitive, ignoreDiacritics} = this.options;
        text = isCaseSensitive ? text : text.toLowerCase();
        text = ignoreDiacritics ? stripDiacritics(text) : text;
        let numMatches = 0;
        let allIndices = [];
        let totalScore = 0;
        for (let i = 0, qLen = query.length; i < qLen; i += 1) {
            const searchers2 = query[i];
            allIndices.length = 0;
            numMatches = 0;
            for (let j = 0, pLen = searchers2.length; j < pLen; j += 1) {
                const searcher = searchers2[j];
                const {isMatch, indices, score} = searcher.search(text);
                if (isMatch) {
                    numMatches += 1;
                    totalScore += score;
                    if (includeMatches) {
                        const type = searcher.constructor.type;
                        if (MultiMatchSet.has(type)) {
                            allIndices = [...allIndices, ...indices];
                        } else {
                            allIndices.push(indices);
                        }
                    }
                } else {
                    totalScore = 0;
                    numMatches = 0;
                    allIndices.length = 0;
                    break;
                }
            }
            if (numMatches) {
                let result = {
                    isMatch: true,
                    score: totalScore / numMatches
                };
                if (includeMatches) {
                    result.indices = allIndices;
                }
                return result;
            }
        }
        return {
            isMatch: false,
            score: 1
        };
    }
}

const registeredSearchers = [];

function register(...args) {
    registeredSearchers.push(...args);
}

function createSearcher(pattern, options) {
    for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
        let searcherClass = registeredSearchers[i];
        if (searcherClass.condition(pattern, options)) {
            return new searcherClass(pattern, options);
        }
    }
    return new BitapSearch(pattern, options);
}

const LogicalOperator = {
    AND: "$and",
    OR: "$or"
};
const KeyType = {
    PATH: "$path",
    PATTERN: "$val"
};
const isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
const isPath = (query) => !!query[KeyType.PATH];
const isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
const convertToExplicit = (query) => ({
    [LogicalOperator.AND]: Object.keys(query).map((key) => ({
        [key]: query[key]
    }))
});

function parse(query, options, {auto = true} = {}) {
    const next = (query2) => {
        let keys = Object.keys(query2);
        const isQueryPath = isPath(query2);
        if (!isQueryPath && keys.length > 1 && !isExpression(query2)) {
            return next(convertToExplicit(query2));
        }
        if (isLeaf(query2)) {
            const key = isQueryPath ? query2[KeyType.PATH] : keys[0];
            const pattern = isQueryPath ? query2[KeyType.PATTERN] : query2[key];
            if (!isString(pattern)) {
                throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
            }
            const obj = {
                keyId: createKeyId(key),
                pattern
            };
            if (auto) {
                obj.searcher = createSearcher(pattern, options);
            }
            return obj;
        }
        let node = {
            children: [],
            operator: keys[0]
        };
        keys.forEach((key) => {
            const value = query2[key];
            if (isArray(value)) {
                value.forEach((item) => {
                    node.children.push(next(item));
                });
            }
        });
        return node;
    };
    if (!isExpression(query)) {
        query = convertToExplicit(query);
    }
    return next(query);
}

function computeScore(results, {ignoreFieldNorm = Config.ignoreFieldNorm}) {
    results.forEach((result) => {
        let totalScore = 1;
        result.matches.forEach(({key, norm: norm2, score}) => {
            const weight = key ? key.weight : null;
            totalScore *= Math.pow(
                score === 0 && weight ? Number.EPSILON : score,
                (weight || 1) * (ignoreFieldNorm ? 1 : norm2)
            );
        });
        result.score = totalScore;
    });
}

function transformMatches(result, data) {
    const matches = result.matches;
    data.matches = [];
    if (!isDefined(matches)) {
        return;
    }
    matches.forEach((match) => {
        if (!isDefined(match.indices) || !match.indices.length) {
            return;
        }
        const {indices, value} = match;
        let obj = {
            indices,
            value
        };
        if (match.key) {
            obj.key = match.key.src;
        }
        if (match.idx > -1) {
            obj.refIndex = match.idx;
        }
        data.matches.push(obj);
    });
}

function transformScore(result, data) {
    data.score = result.score;
}

function format(results, docs, {
    includeMatches = Config.includeMatches,
    includeScore = Config.includeScore
} = {}) {
    const transformers = [];
    if (includeMatches) transformers.push(transformMatches);
    if (includeScore) transformers.push(transformScore);
    return results.map((result) => {
        const {idx} = result;
        const data = {
            item: docs[idx],
            refIndex: idx
        };
        if (transformers.length) {
            transformers.forEach((transformer) => {
                transformer(result, data);
            });
        }
        return data;
    });
}

class Fuse {
    constructor(docs, options = {}, index) {
        this.options = {...Config, ...options};
        if (this.options.useExtendedSearch && false) ;
        this._keyStore = new KeyStore(this.options.keys);
        this.setCollection(docs, index);
    }

    setCollection(docs, index) {
        this._docs = docs;
        if (index && !(index instanceof FuseIndex)) {
            throw new Error(INCORRECT_INDEX_TYPE);
        }
        this._myIndex = index || createIndex(this.options.keys, this._docs, {
            getFn: this.options.getFn,
            fieldNormWeight: this.options.fieldNormWeight
        });
    }

    add(doc) {
        if (!isDefined(doc)) {
            return;
        }
        this._docs.push(doc);
        this._myIndex.add(doc);
    }

    remove(predicate = () => false) {
        const results = [];
        for (let i = 0, len = this._docs.length; i < len; i += 1) {
            const doc = this._docs[i];
            if (predicate(doc, i)) {
                this.removeAt(i);
                i -= 1;
                len -= 1;
                results.push(doc);
            }
        }
        return results;
    }

    removeAt(idx) {
        this._docs.splice(idx, 1);
        this._myIndex.removeAt(idx);
    }

    getIndex() {
        return this._myIndex;
    }

    search(query, {limit = -1} = {}) {
        const {
            includeMatches,
            includeScore,
            shouldSort,
            sortFn,
            ignoreFieldNorm
        } = this.options;
        let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
        computeScore(results, {ignoreFieldNorm});
        if (shouldSort) {
            results.sort(sortFn);
        }
        if (isNumber(limit) && limit > -1) {
            results = results.slice(0, limit);
        }
        return format(results, this._docs, {
            includeMatches,
            includeScore
        });
    }

    _searchStringList(query) {
        const searcher = createSearcher(query, this.options);
        const {records} = this._myIndex;
        const results = [];
        records.forEach(({v: text, i: idx, n: norm2}) => {
            if (!isDefined(text)) {
                return;
            }
            const {isMatch, score, indices} = searcher.searchIn(text);
            if (isMatch) {
                results.push({
                    item: text,
                    idx,
                    matches: [{score, value: text, norm: norm2, indices}]
                });
            }
        });
        return results;
    }

    _searchLogical(query) {
        const expression = parse(query, this.options);
        const evaluate = (node, item, idx) => {
            if (!node.children) {
                const {keyId, searcher} = node;
                const matches = this._findMatches({
                    key: this._keyStore.get(keyId),
                    value: this._myIndex.getValueForItemAtKeyId(item, keyId),
                    searcher
                });
                if (matches && matches.length) {
                    return [
                        {
                            idx,
                            item,
                            matches
                        }
                    ];
                }
                return [];
            }
            const res = [];
            for (let i = 0, len = node.children.length; i < len; i += 1) {
                const child = node.children[i];
                const result = evaluate(child, item, idx);
                if (result.length) {
                    res.push(...result);
                } else if (node.operator === LogicalOperator.AND) {
                    return [];
                }
            }
            return res;
        };
        const records = this._myIndex.records;
        const resultMap = {};
        const results = [];
        records.forEach(({$: item, i: idx}) => {
            if (isDefined(item)) {
                let expResults = evaluate(expression, item, idx);
                if (expResults.length) {
                    if (!resultMap[idx]) {
                        resultMap[idx] = {idx, item, matches: []};
                        results.push(resultMap[idx]);
                    }
                    expResults.forEach(({matches}) => {
                        resultMap[idx].matches.push(...matches);
                    });
                }
            }
        });
        return results;
    }

    _searchObjectList(query) {
        const searcher = createSearcher(query, this.options);
        const {keys, records} = this._myIndex;
        const results = [];
        records.forEach(({$: item, i: idx}) => {
            if (!isDefined(item)) {
                return;
            }
            let matches = [];
            keys.forEach((key, keyIndex) => {
                matches.push(
                    ...this._findMatches({
                        key,
                        value: item[keyIndex],
                        searcher
                    })
                );
            });
            if (matches.length) {
                results.push({
                    idx,
                    item,
                    matches
                });
            }
        });
        return results;
    }

    _findMatches({key, value, searcher}) {
        if (!isDefined(value)) {
            return [];
        }
        let matches = [];
        if (isArray(value)) {
            value.forEach(({v: text, i: idx, n: norm2}) => {
                if (!isDefined(text)) {
                    return;
                }
                const {isMatch, score, indices} = searcher.searchIn(text);
                if (isMatch) {
                    matches.push({
                        score,
                        key,
                        value: text,
                        idx,
                        norm: norm2,
                        indices
                    });
                }
            });
        } else {
            const {v: text, n: norm2} = value;
            const {isMatch, score, indices} = searcher.searchIn(text);
            if (isMatch) {
                matches.push({score, key, value: text, norm: norm2, indices});
            }
        }
        return matches;
    }
}

Fuse.version = "7.1.0";
Fuse.createIndex = createIndex;
Fuse.parseIndex = parseIndex;
Fuse.config = Config;
{
    Fuse.parseQuery = parse;
}
{
    register(ExtendedSearch);
}
const _hoisted_1$3 = {class: "h-full w-640px flex flex-col"};
const _hoisted_2$3 = {
    flex: "~ gap2 none items-center justify-between",
    border: "b base",
    class: "relative bg-hover px-4 py-1"
};
const _hoisted_3$3 = {class: "font-600"};
const _hoisted_4$3 = {class: "flex-1 overflow-y-overlay p-3"};
const _sfc_main$4 = /* @__PURE__ */ defineComponent({
    __name: "model-detail-drawer",
    props: /* @__PURE__ */ mergeModels({
        model: {}
    }, {
        "modelValue": {type: Boolean},
        "modelModifiers": {}
    }),
    emits: ["update:modelValue"],
    setup(__props) {
        const props = __props;
        const show = useModel(__props, "modelValue");
        const formatedModel = computed(() => {
            if (!props.model)
                return null;
            const decodedModel = {
                ...props.model,
                sql: void 0,
                createTime: props.model.createTime ? formatToDateTime(props.model.createTime) : void 0,
                updateTime: props.model.updateTime ? formatToDateTime(props.model.updateTime) : void 0
            };
            return JSON.stringify(decodedModel, null, 2);
        });
        const {copy, copied} = useCopy();
        const {copy: copySql, copied: sqlCopied} = useCopy();
        return (_ctx, _cache) => {
            const _component_ShikiCode = _sfc_main$7;
            const _component_SimpleCollapse = _sfc_main$8;
            const _component_Empty = _sfc_main$9;
            const _component_SimpleDrawer = _sfc_main$6;
            return openBlock(), createBlock(_component_SimpleDrawer, {
                modelValue: show.value,
                "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => show.value = $event)
            }, {
                default: withCtx(() => {
                    var _a, _b, _c;
                    return [
                        createBaseVNode("div", _hoisted_1$3, [
                            createBaseVNode("div", _hoisted_2$3, [
                                createBaseVNode("span", _hoisted_3$3, "模型【" + toDisplayString((_a = _ctx.model) == null ? void 0 : _a.modelName) + " - " + toDisplayString((_b = _ctx.model) == null ? void 0 : _b.id) + "】详情", 1)
                            ]),
                            createBaseVNode("div", _hoisted_4$3, [
                                unref(formatedModel) ? (openBlock(), createElementBlock(Fragment, {key: 0}, [
                                    createVNode(_component_SimpleCollapse, {
                                        "model-value": true,
                                        "header-class": "bg-selected"
                                    }, {
                                        title: withCtx(() => _cache[3] || (_cache[3] = [
                                            createTextVNode(" 基本信息 ")
                                        ])),
                                        actions: withCtx(() => [
                                            createBaseVNode("button", {
                                                class: "a-primary",
                                                onClick: _cache[0] || (_cache[0] = ($event) => unref(copy)(unref(formatedModel)))
                                            }, toDisplayString(unref(copied) ? "✓ 已复制" : "复制"), 1)
                                        ]),
                                        default: withCtx(() => [
                                            createVNode(_component_ShikiCode, {
                                                code: unref(formatedModel),
                                                lang: "json",
                                                class: "bg-blue/10 text-0.9rem"
                                            }, null, 8, ["code"])
                                        ]),
                                        _: 1
                                    }),
                                    ((_c = _ctx.model) == null ? void 0 : _c.sql) ? (openBlock(), createBlock(_component_SimpleCollapse, {
                                        key: 0,
                                        "model-value": true,
                                        class: "mt-3",
                                        "header-class": "bg-selected"
                                    }, {
                                        title: withCtx(() => _cache[4] || (_cache[4] = [
                                            createTextVNode(" SQL 信息 ")
                                        ])),
                                        actions: withCtx(() => [
                                            createBaseVNode("button", {
                                                class: "a-primary",
                                                onClick: _cache[1] || (_cache[1] = ($event) => {
                                                    var _a2;
                                                    return unref(copySql)((_a2 = _ctx.model) == null ? void 0 : _a2.sql);
                                                })
                                            }, toDisplayString(unref(sqlCopied) ? "✓ 已复制" : "复制"), 1)
                                        ]),
                                        default: withCtx(() => [
                                            createVNode(_component_ShikiCode, {
                                                code: _ctx.model.sql,
                                                lang: "sql",
                                                class: "bg-yellow/10 text-0.9rem"
                                            }, null, 8, ["code"])
                                        ]),
                                        _: 1
                                    })) : createCommentVNode("", true)
                                ], 64)) : (openBlock(), createBlock(_component_Empty, {
                                    key: 1,
                                    class: "h-full"
                                }, {
                                    default: withCtx(() => _cache[5] || (_cache[5] = [
                                        createTextVNode(" 暂无详情 ")
                                    ])),
                                    _: 1
                                }))
                            ])
                        ])
                    ];
                }),
                _: 1
            }, 8, ["modelValue"]);
        };
    }
});
const _hoisted_1$2 = {class: "w-36 flex flex-col gap-1 p1 text-0.9rem"};
const _hoisted_2$2 = ["title"];
const _hoisted_3$2 = {class: "flex flex-wrap items-center gap-2"};
const _hoisted_4$2 = {class: "relative mt-auto flex items-center gap-2"};
const _hoisted_5$2 = ["title"];
const _sfc_main$3 = /* @__PURE__ */ defineComponent({
    __name: "model-item",
    props: {
        model: {},
        viewType: {}
    },
    emits: ["showDetail", "showEdit", "delete", "showPegging", "showJobs", "createJob"],
    setup(__props) {
        useCssVars((_ctx) => ({
            "1c368f7c": unref(hoverBgStyle),
            "304a35a4": unref(scopeStyle).color
        }));
        const props = __props;
        const [DefineDropdown, ReuseDropdown] = createReusableTemplate();
        const showMenu = ref(false);
        const groupStyle = computed(() => ({
            background: "linear-gradient(135deg, ".concat(getHashColorFromString(props.model.scope || "", 0.08), ", ").concat(getHashColorFromString(props.model.scope || "", 0), ")"),
            borderColor: getHashColorFromString(props.model.scope || "", 0.3)
        }));
        const hoverBgStyle = computed(() => {
            return "linear-gradient(135deg, ".concat(getHashColorFromString(props.model.scope || "", 0.15), ", ").concat(getHashColorFromString(props.model.scope || "", 0), ")");
        });
        const scopeStyle = computed(() => ({
            backgroundColor: getHashColorFromString(props.model.scope || "", 0.1),
            color: getHashColorFromString(props.model.scope || "", 1)
        }));
        return (_ctx, _cache) => {
            const _component_VDropdown = resolveComponent("VDropdown");
            return openBlock(), createElementBlock(Fragment, null, [
                createVNode(unref(DefineDropdown), null, {
                    default: withCtx(() => [
                        createVNode(_component_VDropdown, {
                            shown: unref(showMenu),
                            "onUpdate:shown": _cache[6] || (_cache[6] = ($event) => isRef(showMenu) ? showMenu.value = $event : null),
                            "popper-class": "no-arrow",
                            placement: "bottom-end",
                            "popper-triggers": ["hover"]
                        }, {
                            popper: withCtx(() => [
                                createBaseVNode("div", _hoisted_1$2, [
                                    createBaseVNode("button", {
                                        class: "rounded-md px3 py1 text-left hover:bg-gray/15",
                                        onClick: _cache[0] || (_cache[0] = ($event) => {
                                            showMenu.value = false;
                                            _ctx.$emit("showDetail");
                                        })
                                    }, _cache[10] || (_cache[10] = [
                                        createBaseVNode("span", {class: "op80"}, "详情", -1)
                                    ])),
                                    createBaseVNode("button", {
                                        class: "rounded-md px3 py1 text-left hover:bg-gray/15",
                                        onClick: _cache[1] || (_cache[1] = ($event) => {
                                            showMenu.value = false;
                                            _ctx.$emit("showEdit");
                                        })
                                    }, _cache[11] || (_cache[11] = [
                                        createBaseVNode("span", {class: "op80"}, "编辑", -1)
                                    ])),
                                    _cache[16] || (_cache[16] = createBaseVNode("div", {class: "h-1px w-full bg-gray/20"}, null, -1)),
                                    createBaseVNode("button", {
                                        class: "rounded-md px3 py1 text-left hover:bg-gray/15",
                                        onClick: _cache[2] || (_cache[2] = ($event) => {
                                            showMenu.value = false;
                                            _ctx.$emit("createJob");
                                        })
                                    }, _cache[12] || (_cache[12] = [
                                        createBaseVNode("div", {class: "flex items-center gap-1 op80"}, [
                                            createTextVNode(" 创建任务 "),
                                            createBaseVNode("div", {class: "i-ph:arrow-up-right"})
                                        ], -1)
                                    ])),
                                    createBaseVNode("button", {
                                        class: "rounded-md px3 py1 text-left hover:bg-gray/15",
                                        onClick: _cache[3] || (_cache[3] = ($event) => {
                                            showMenu.value = false;
                                            _ctx.$emit("showJobs");
                                        })
                                    }, _cache[13] || (_cache[13] = [
                                        createBaseVNode("div", {class: "flex items-center gap-1 op80"}, [
                                            createTextVNode(" 查看关联任务 "),
                                            createBaseVNode("div", {class: "i-ph:arrow-up-right"})
                                        ], -1)
                                    ])),
                                    createBaseVNode("button", {
                                        class: "rounded-md px3 py1 text-left hover:bg-gray/15",
                                        onClick: _cache[4] || (_cache[4] = ($event) => {
                                            showMenu.value = false;
                                            _ctx.$emit("showPegging");
                                        })
                                    }, _cache[14] || (_cache[14] = [
                                        createBaseVNode("span", {class: "op80"}, "反查绑定关系", -1)
                                    ])),
                                    _cache[17] || (_cache[17] = createBaseVNode("div", {class: "h-1px w-full bg-gray/20"}, null, -1)),
                                    createBaseVNode("button", {
                                        class: "rounded-md px3 py1 text-left hover:bg-red/10",
                                        onClick: _cache[5] || (_cache[5] = ($event) => {
                                            showMenu.value = false;
                                            _ctx.$emit("delete");
                                        })
                                    }, _cache[15] || (_cache[15] = [
                                        createBaseVNode("span", {class: "text-red"}, "删除", -1)
                                    ]))
                                ])
                            ]),
                            default: withCtx(() => [
                                createBaseVNode("div", {
                                    class: normalizeClass(["h-6 w-6 flex-center flex-none cursor-pointer rounded op0 hover:bg-gray/30 group-hover:op70", {"op70 bg-gray/30": unref(showMenu)}])
                                }, _cache[9] || (_cache[9] = [
                                    createBaseVNode("div", {class: "i-ph:dots-three-outline-fill op60"}, null, -1)
                                ]), 2)
                            ]),
                            _: 1
                        }, 8, ["shown"])
                    ]),
                    _: 1
                }),
                _ctx.viewType === "grid" ? (openBlock(), createElementBlock("div", {
                    key: 0,
                    class: "group relative flex flex-col gap-3 border-2px rounded-lg bg-op10 px-4 py3",
                    style: normalizeStyle(unref(groupStyle))
                }, [
                    createBaseVNode("div", {
                        class: normalizeClass(["absolute right-1 top-1 overflow-hidden text-3rem op6", _ctx.model.modelType === "graph" ? "i-carbon:network-4" : "i-carbon:table-split"]),
                        style: normalizeStyle({color: unref(scopeStyle).color})
                    }, null, 6),
                    createBaseVNode("div", {
                        class: "model-name w-fit cursor-pointer color-gray-500 font-600",
                        onClick: _cache[7] || (_cache[7] = ($event) => _ctx.$emit("showDetail"))
                    }, toDisplayString(_ctx.model.modelName), 1),
                    createBaseVNode("div", {
                        class: "line-clamp-2 h-10 text-sm op50",
                        title: _ctx.model.description
                    }, toDisplayString(_ctx.model.description), 9, _hoisted_2$2),
                    createBaseVNode("div", _hoisted_3$2, [
                        (openBlock(true), createElementBlock(Fragment, null, renderList(JSON.parse(_ctx.model.tags || "[]"), (tag) => {
                            return openBlock(), createElementBlock("span", {
                                key: tag,
                                class: "rounded bg-gray/20 px2 py1 text-xs color-fade"
                            }, " #" + toDisplayString(tag), 1);
                        }), 128))
                    ]),
                    createBaseVNode("div", _hoisted_4$2, [
                        createBaseVNode("div", {
                            class: "badge rounded-full text-0.8rem",
                            style: normalizeStyle(unref(scopeStyle))
                        }, toDisplayString(_ctx.model.scope), 5),
                        _cache[18] || (_cache[18] = createBaseVNode("div", {class: "flex-auto"}, null, -1)),
                        createVNode(unref(ReuseDropdown))
                    ])
                ], 4)) : _ctx.viewType === "list" ? (openBlock(), createElementBlock("div", {
                    key: 1,
                    class: "group flex items-center gap-2 border-2px rounded-md bg-op10 px-3 py-2",
                    style: normalizeStyle(unref(groupStyle))
                }, [
                    createBaseVNode("div", {
                        class: normalizeClass(["flex-none op70", _ctx.model.modelType === "graph" ? "i-carbon:network-4" : "i-carbon:table-split"]),
                        style: normalizeStyle({color: unref(scopeStyle).color})
                    }, null, 6),
                    createBaseVNode("div", {
                        class: "model-name w-fit cursor-pointer color-gray-500 font-600",
                        onClick: _cache[8] || (_cache[8] = ($event) => _ctx.$emit("showDetail"))
                    }, toDisplayString(_ctx.model.modelName), 1),
                    createBaseVNode("div", {
                        class: "mx-2 badge rounded-full px-2.5 text-0.8rem",
                        style: normalizeStyle(unref(scopeStyle))
                    }, toDisplayString(_ctx.model.scope), 5),
                    createBaseVNode("div", {
                        class: "line-clamp-1 flex-[4_1_0] text-sm op50",
                        title: _ctx.model.description
                    }, toDisplayString(_ctx.model.description), 9, _hoisted_5$2),
                    _cache[19] || (_cache[19] = createBaseVNode("div", {class: "flex-auto"}, null, -1)),
                    createVNode(unref(ReuseDropdown))
                ], 4)) : createCommentVNode("", true)
            ], 64);
        };
    }
});
const ModelItem = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-ba445398"]]);
const _sfc_main$2 = /* @__PURE__ */ defineComponent({
    __name: "SimpleTitle",
    props: {
        bar: {type: Boolean}
    },
    setup(__props) {
        return (_ctx, _cache) => {
            return openBlock(), createElementBlock("span", {
                class: normalizeClass(["relative flex whitespace-nowrap", [{"pl-10px bar": _ctx.bar && _ctx.$slots.default}]])
            }, [
                renderSlot(_ctx.$slots, "default", {}, void 0, true)
            ], 2);
        };
    }
});
const __unplugin_components_0 = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-f49db258"]]);
const _hoisted_1$1 = {class: "h-full w-800px flex flex-col"};
const _hoisted_2$1 = {
    flex: "~ gap2 none items-center justify-between",
    border: "b base",
    class: "relative bg-hover px-4 py-1"
};
const _hoisted_3$1 = {class: "font-600"};
const _hoisted_4$1 = {class: "flex flex-1 flex-col gap-4 overflow-y-overlay p-4"};
const _hoisted_5$1 = {class: "flex items-center gap-2"};
const _hoisted_6$1 = {class: "form-group w-40%"};
const _hoisted_7$1 = ["value"];
const _hoisted_8$1 = {class: "form-group w-30%"};
const _hoisted_9$1 = {class: "form-group w-30%"};
const _hoisted_10$1 = {key: 1};
const _hoisted_11$1 = {class: "color-base"};
const _hoisted_12$1 = {class: "green-badge"};
const _hoisted_13$1 = {class: "blue-badge"};
const _sfc_main$1 = /* @__PURE__ */ defineComponent({
    __name: "model-pegging-drawer",
    props: /* @__PURE__ */ mergeModels({
        model: {}
    }, {
        "modelValue": {type: Boolean},
        "modelModifiers": {}
    }),
    emits: ["update:modelValue"],
    setup(__props) {
        const props = __props;
        const show = useModel(__props, "modelValue");
        const peggingList = ref([]);

        function getPeggingList() {
            var _a;
            getModelPeggings({modelId: (_a = props.model) == null ? void 0 : _a.id}).then((res) => {
                peggingList.value = res.data;
            }).catch(() => {
                peggingList.value = [];
            });
        }

        onMounted(() => {
            getPeggingList();
        });

        function handlePeggingInfo(item) {
            var _a, _b;
            const key = Object.keys(item)[0];
            const countScriptId = (_a = item[key].find((i) => i.scriptType === "COUNT")) == null ? void 0 : _a.scriptId;
            const dataScriptId = (_b = item[key].find((i) => i.scriptType === "DATA")) == null ? void 0 : _b.scriptId;
            return {key, countScriptId, dataScriptId};
        }

        const formInfo = ref({
            columnName: "",
            countScriptId: "",
            dataScriptId: ""
        });

        function handleCreatePegging() {
            var _a;
            if (!formInfo.value.columnName || !formInfo.value.countScriptId || !formInfo.value.dataScriptId) {
                api.warning("请输入完整信息");
                return;
            }
            const params = {
                modelId: (_a = props.model) == null ? void 0 : _a.id,
                ...formInfo.value
            };
            createModelPeggingMap(params).then(() => {
                api.success("创建成功");
                getPeggingList();
            });
        }

        return (_ctx, _cache) => {
            const _component_SimpleTitle = __unplugin_components_0;
            const _component_SimpleSelect = _sfc_main$a;
            const _component_SimpleInput = _sfc_main$b;
            const _component_SimpleButton = _sfc_main$c;
            const _component_Empty = _sfc_main$9;
            const _component_SimpleDrawer = _sfc_main$6;
            return openBlock(), createBlock(_component_SimpleDrawer, {
                modelValue: show.value,
                "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => show.value = $event)
            }, {
                default: withCtx(() => {
                    var _a, _b;
                    return [
                        createBaseVNode("div", _hoisted_1$1, [
                            createBaseVNode("div", _hoisted_2$1, [
                                createBaseVNode("span", _hoisted_3$1, "模型【" + toDisplayString((_a = _ctx.model) == null ? void 0 : _a.modelName) + " - " + toDisplayString((_b = _ctx.model) == null ? void 0 : _b.id) + "】反查绑定", 1)
                            ]),
                            createBaseVNode("div", _hoisted_4$1, [
                                createVNode(_component_SimpleTitle, {
                                    bar: "",
                                    class: "font-600"
                                }, {
                                    default: withCtx(() => _cache[4] || (_cache[4] = [
                                        createTextVNode(" 创建反查绑定关系 ")
                                    ])),
                                    _: 1
                                }),
                                createBaseVNode("div", _hoisted_5$1, [
                                    createBaseVNode("div", _hoisted_6$1, [
                                        _cache[5] || (_cache[5] = createBaseVNode("label", null, [
                                            createBaseVNode("span", {"text-red-500": ""}, "*"),
                                            createTextVNode(" COLUMN_NAME")
                                        ], -1)),
                                        createVNode(_component_SimpleSelect, {
                                            modelValue: unref(formInfo).columnName,
                                            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(formInfo).columnName = $event),
                                            placeholder: "请选择"
                                        }, {
                                            default: withCtx(() => {
                                                var _a2;
                                                return [
                                                    (openBlock(true), createElementBlock(Fragment, null, renderList(((_a2 = _ctx.model) == null ? void 0 : _a2.resultMeta) || [], (item) => {
                                                        return openBlock(), createElementBlock("option", {
                                                            key: item,
                                                            value: item.columnName
                                                        }, toDisplayString(item.desc) + " - " + toDisplayString(item.columnName), 9, _hoisted_7$1);
                                                    }), 128))
                                                ];
                                            }),
                                            _: 1
                                        }, 8, ["modelValue"])
                                    ]),
                                    createBaseVNode("div", _hoisted_8$1, [
                                        _cache[6] || (_cache[6] = createBaseVNode("label", null, [
                                            createBaseVNode("span", {"text-red-500": ""}, "*"),
                                            createTextVNode(" COUNT_ID")
                                        ], -1)),
                                        createVNode(_component_SimpleInput, {
                                            modelValue: unref(formInfo).countScriptId,
                                            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => unref(formInfo).countScriptId = $event),
                                            modelModifiers: {trim: true},
                                            maxlength: 32,
                                            placeholder: "请输入"
                                        }, null, 8, ["modelValue"])
                                    ]),
                                    createBaseVNode("div", _hoisted_9$1, [
                                        _cache[7] || (_cache[7] = createBaseVNode("label", null, [
                                            createBaseVNode("span", {"text-red-500": ""}, "*"),
                                            createTextVNode(" DATA_ID")
                                        ], -1)),
                                        createVNode(_component_SimpleInput, {
                                            modelValue: unref(formInfo).dataScriptId,
                                            "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => unref(formInfo).dataScriptId = $event),
                                            modelModifiers: {trim: true},
                                            maxlength: 32,
                                            placeholder: "请输入"
                                        }, null, 8, ["modelValue"])
                                    ])
                                ]),
                                createVNode(_component_SimpleButton, {
                                    class: "flex-none",
                                    type: "primary",
                                    onClick: handleCreatePegging
                                }, {
                                    default: withCtx(() => _cache[8] || (_cache[8] = [
                                        createTextVNode(" 创建 ")
                                    ])),
                                    _: 1
                                }),
                                _cache[12] || (_cache[12] = createBaseVNode("hr", {class: "mx-auto my-4 w-50%"}, null, -1)),
                                createVNode(_component_SimpleTitle, {
                                    bar: "",
                                    class: "font-600"
                                }, {
                                    default: withCtx(() => _cache[9] || (_cache[9] = [
                                        createTextVNode(" 当前反查绑定数据 ")
                                    ])),
                                    _: 1
                                }),
                                unref(peggingList).length === 0 ? (openBlock(), createBlock(_component_Empty, {
                                    key: 0,
                                    class: "h-full"
                                }, {
                                    default: withCtx(() => _cache[10] || (_cache[10] = [
                                        createTextVNode(" 暂无绑定数据 ")
                                    ])),
                                    _: 1
                                })) : (openBlock(), createElementBlock("div", _hoisted_10$1, [
                                    _cache[11] || (_cache[11] = createBaseVNode("div", {
                                        border: "b base",
                                        class: "h-36px w-full flex flex-nowrap items-center justify-between gap-1 bg-hover px-4 text-sm"
                                    }, [
                                        createBaseVNode("span", {class: "color-base font-600"}, "COLUMN_NAME"),
                                        createBaseVNode("span", {class: "color-base font-600"}, "COUNT_ID"),
                                        createBaseVNode("span", {class: "color-base font-600"}, "DATA_ID")
                                    ], -1)),
                                    (openBlock(true), createElementBlock(Fragment, null, renderList(unref(peggingList), (item, index) => {
                                        return openBlock(), createElementBlock("div", {
                                            key: index,
                                            border: "b base",
                                            class: "h-36px w-full flex flex-nowrap items-center justify-between gap-1 hover:bg-hover px-4 text-sm"
                                        }, [
                                            createBaseVNode("code", _hoisted_11$1, toDisplayString(handlePeggingInfo(item).key), 1),
                                            createBaseVNode("code", _hoisted_12$1, toDisplayString(handlePeggingInfo(item).countScriptId), 1),
                                            createBaseVNode("code", _hoisted_13$1, toDisplayString(handlePeggingInfo(item).dataScriptId), 1)
                                        ]);
                                    }), 128))
                                ]))
                            ])
                        ])
                    ];
                }),
                _: 1
            }, 8, ["modelValue"]);
        };
    }
});
const _hoisted_1 = {class: "h-full flex flex-col overflow-y-overlay rounded-lg bg-base p4"};
const _hoisted_2 = {class: "relative mx-auto w-50% py-4"};
const _hoisted_3 = {class: "grid grid-cols-[max-content_1fr] items-center gap-2 pb-4"};
const _hoisted_4 = {class: "flex items-center gap-2"};
const _hoisted_5 = {class: "h-8 purple-badge gap-1 border border-purple-200 rounded"};
const _hoisted_6 = {class: "text-0.9rem op70"};
const _hoisted_7 = {class: "mt-4 flex-1"};
const _hoisted_8 = {
    key: 2,
    class: "h-full flex-center"
};
const _hoisted_9 = {class: "h-full w-700px flex flex-col"};
const _hoisted_10 = {
    flex: "~ gap2 none items-center justify-between",
    border: "b base",
    class: "relative bg-hover px-4 py-1"
};
const _hoisted_11 = {class: "font-600"};
const _hoisted_12 = {class: "flex items-center gap-4"};
const _hoisted_13 = {class: "mt-4 flex justify-end gap-4"};
const _sfc_main = /* @__PURE__ */ defineComponent({
    __name: "index",
    setup(__props) {
        const appStore = useAppStore();
        const {modelViewType} = storeToRefs(appStore);
        const models = ref([]);
        const loading = ref(false);
        const allTags = ref([]);
        const conditionalFiltered = computed(() => {
            let conditional = models.value;
            if (modelFilters.tags.length) {
                conditional = conditional.filter((model) => {
                    const tags = JSON.parse(model.tags || "[]");
                    return tags.some((tag) => modelFilters.tags.includes(tag));
                });
            }
            return conditional;
        });
        const fuse = computed(() => new Fuse(conditionalFiltered.value, {
            keys: ["modelName", "desciption", "tags", "scope"],
            threshold: 0.5
        }));
        const filtered = ref(conditionalFiltered.value);
        watchDebounced(
            () => [modelFilters.search, conditionalFiltered.value],
            () => {
                if (!modelFilters.search)
                    return filtered.value = conditionalFiltered.value;
                filtered.value = fuse.value.search(modelFilters.search).map((i) => i.item);
            },
            {debounce: 200}
        );
        const isDefaultFilters = computed(() => !(modelFilters.search || modelFilters.tags.length));

        function resetFilters() {
            modelFilters.search = "";
            modelFilters.tags = [];
        }

        function getModels() {
            const params = {
                query: 1,
                pageSize: 800
            };
            loading.value = true;
            getModelList(params).then((res) => {
                models.value = res.data;
            }).catch(() => {
                models.value = [];
            }).finally(() => {
                loading.value = false;
            });
        }

        function getTags() {
            getAllTags().then((res) => {
                allTags.value = res.data.map((i) => i.tagName);
            }).catch(() => {
                allTags.value = [];
            });
        }

        onMounted(() => {
            getModels();
            getTags();
        });
        const selectedModel = ref();
        const showDetailDrawer = ref(false);

        function handleDetail(model) {
            selectedModel.value = Object.assign({}, model);
            showDetailDrawer.value = true;
        }

        const router = useRouter();

        function handleCreateJob(model) {
            window.open(router.resolve({
                name: "JobCreate",
                query: {
                    modelIdFromModelPage: model.id
                }
            }).href, "_blank");
        }

        function handleShowJobs(model) {
            window.open(router.resolve({
                name: "JobList",
                query: {
                    modelIdFromModelPage: model.id,
                    modelNameFromModelPage: encodeURIComponent(model.modelName)
                }
            }).href, "_blank");
        }

        const showPeggingDrawer = ref(false);

        function handleShowPegging(model) {
            selectedModel.value = Object.assign({}, model);
            showPeggingDrawer.value = true;
        }

        const showEditDrawer = ref(false);

        function handleEdit(model) {
            selectedModel.value = Object.assign({}, model);
            showEditDrawer.value = true;
        }

        const deleteVisible = ref(false);

        function handleDelete(model) {
            selectedModel.value = Object.assign({}, model);
            deleteVisible.value = true;
        }

        function confirmDelete() {
            var _a;
            deleteModel((_a = selectedModel.value) == null ? void 0 : _a.id).then(() => {
                deleteVisible.value = false;
            });
        }

        function handleSuccess() {
            getModels();
            showEditDrawer.value = false;
        }

        return (_ctx, _cache) => {
            const _component_SelectGroup = _sfc_main$d;
            const _component_ViewType = __unplugin_components_1;
            const _component_Loading = _sfc_main$e;
            const _component_Empty = _sfc_main$9;
            const _component_IconButton = _sfc_main$f;
            const _component_SimpleDrawer = _sfc_main$6;
            const _component_SimpleButton = _sfc_main$c;
            const _component_SimpleDialog = _sfc_main$h;
            return openBlock(), createElementBlock("div", _hoisted_1, [
                unref(models) && unref(models).length > 0 ? (openBlock(), createElementBlock(Fragment, {key: 0}, [
                    createBaseVNode("div", _hoisted_2, [
                        withDirectives(createBaseVNode("input", {
                            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(modelFilters).search = $event),
                            placeholder: "模型搜索...",
                            maxlength: "100",
                            class: "w-full border-2px border-base rounded-xl bg-transparent px3 py2 pl10 outline-none focus:border-primary"
                        }, null, 512), [
                            [vModelText, unref(modelFilters).search]
                        ]),
                        _cache[10] || (_cache[10] = createBaseVNode("div", {class: "absolute bottom-0 left-0 top-0 flex-center p4 op50"}, [
                            createBaseVNode("div", {class: "i-ph-magnifying-glass-duotone text-1.1rem"})
                        ], -1))
                    ]),
                    createBaseVNode("div", _hoisted_3, [
                        _cache[11] || (_cache[11] = createBaseVNode("div", {class: "text-right text-sm font-500 op60"}, " 标签： ", -1)),
                        createVNode(_component_SelectGroup, {
                            modelValue: unref(modelFilters).tags,
                            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => unref(modelFilters).tags = $event),
                            multiple: "",
                            options: unref(allTags),
                            titles: unref(allTags).map((i) => "#".concat(i))
                        }, null, 8, ["modelValue", "options", "titles"])
                    ]),
                    createBaseVNode("div", _hoisted_4, [
                        createBaseVNode("div", _hoisted_5, [
                            createBaseVNode("span", null, toDisplayString(unref(filtered).length), 1),
                            createBaseVNode("span", _hoisted_6, "/ " + toDisplayString(unref(models).length) + " 模型", 1)
                        ]),
                        !unref(isDefaultFilters) ? (openBlock(), createElementBlock("button", {
                            key: 0,
                            class: "h-8 inline-flex orange-badge gap-1 border border-orange-200 text-0.9rem text-op70 hover:text-op100",
                            onClick: _cache[2] || (_cache[2] = ($event) => resetFilters())
                        }, _cache[12] || (_cache[12] = [
                            createBaseVNode("div", {class: "i-ph:funnel-duotone"}, null, -1),
                            createBaseVNode("span", {class: ""}, "重置", -1),
                            createBaseVNode("div", {class: "i-ph-x cursor-pointer op70"}, null, -1)
                        ]))) : (openBlock(), createElementBlock("button", {
                            key: 1,
                            class: "h-8 gray-badge gap-1 border border-gray-200 text-0.9rem text-op70 hover:text-op100",
                            onClick: getModels
                        }, _cache[13] || (_cache[13] = [
                            createBaseVNode("div", {class: "i-mdi:refresh"}, null, -1),
                            createTextVNode(" 刷新 ")
                        ]))),
                        createVNode(_component_ViewType, {
                            modelValue: unref(modelViewType),
                            "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => isRef(modelViewType) ? modelViewType.value = $event : null),
                            class: "ml-auto h-8"
                        }, null, 8, ["modelValue"])
                    ])
                ], 64)) : createCommentVNode("", true),
                createBaseVNode("div", _hoisted_7, [
                    unref(loading) ? (openBlock(), createBlock(_component_Loading, {key: 0})) : unref(models) && unref(models).length > 0 ? (openBlock(), createElementBlock("div", {
                        key: 1,
                        class: normalizeClass(["px-0 py-2", unref(modelViewType) === "grid" ? "grid grid-cols-[repeat(auto-fill,minmax(min(100%,300px),1fr))] gap-5 px-0 py-2" : "flex flex-col gap-2"])
                    }, [
                        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(filtered), (model, idx) => {
                            return openBlock(), createBlock(ModelItem, {
                                key: idx,
                                model,
                                "view-type": unref(modelViewType),
                                onShowDetail: ($event) => handleDetail(model),
                                onShowEdit: ($event) => handleEdit(model),
                                onDelete: ($event) => handleDelete(model),
                                onShowPegging: ($event) => handleShowPegging(model),
                                onShowJobs: ($event) => handleShowJobs(model),
                                onCreateJob: ($event) => handleCreateJob(model)
                            }, null, 8, ["model", "view-type", "onShowDetail", "onShowEdit", "onDelete", "onShowPegging", "onShowJobs", "onCreateJob"]);
                        }), 128))
                    ], 2)) : (openBlock(), createElementBlock("div", _hoisted_8, [
                        createVNode(_component_Empty, {icon: "i-carbon:border-none op60 text-1.4rem"}, {
                            default: withCtx(() => _cache[14] || (_cache[14] = [
                                createBaseVNode("span", {class: "op60"}, "暂无模型", -1)
                            ])),
                            _: 1
                        })
                    ]))
                ]),
                unref(showDetailDrawer) ? (openBlock(), createBlock(_sfc_main$4, {
                    key: 1,
                    modelValue: unref(showDetailDrawer),
                    "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => isRef(showDetailDrawer) ? showDetailDrawer.value = $event : null),
                    model: unref(selectedModel)
                }, null, 8, ["modelValue", "model"])) : createCommentVNode("", true),
                unref(showPeggingDrawer) ? (openBlock(), createBlock(_sfc_main$1, {
                    key: 2,
                    modelValue: unref(showPeggingDrawer),
                    "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => isRef(showPeggingDrawer) ? showPeggingDrawer.value = $event : null),
                    model: unref(selectedModel)
                }, null, 8, ["modelValue", "model"])) : createCommentVNode("", true),
                createVNode(_component_SimpleDrawer, {
                    modelValue: unref(showEditDrawer),
                    "onUpdate:modelValue": _cache[7] || (_cache[7] = ($event) => isRef(showEditDrawer) ? showEditDrawer.value = $event : null)
                }, {
                    default: withCtx(() => {
                        var _a, _b;
                        return [
                            createBaseVNode("div", _hoisted_9, [
                                createBaseVNode("div", _hoisted_10, [
                                    createBaseVNode("span", _hoisted_11, "模型【" + toDisplayString((_a = unref(selectedModel)) == null ? void 0 : _a.modelName) + " - " + toDisplayString((_b = unref(selectedModel)) == null ? void 0 : _b.id) + "】编辑", 1),
                                    createVNode(_component_IconButton, {
                                        "icon-class": "i-carbon:close text-1.2rem",
                                        onClick: _cache[6] || (_cache[6] = ($event) => showEditDrawer.value = false)
                                    })
                                ]),
                                createVNode(_sfc_main$g, {
                                    model: unref(selectedModel),
                                    type: "UPDATE",
                                    class: "flex-1 overflow-y-auto p-6 pb-10",
                                    onSuccess: handleSuccess
                                }, null, 8, ["model"])
                            ])
                        ];
                    }),
                    _: 1
                }, 8, ["modelValue"]),
                createVNode(_component_SimpleDialog, {
                    modelValue: unref(deleteVisible),
                    "onUpdate:modelValue": _cache[9] || (_cache[9] = ($event) => isRef(deleteVisible) ? deleteVisible.value = $event : null),
                    class: "flex flex-col gap-4 p-6 !w-400px"
                }, {
                    default: withCtx(() => {
                        var _a;
                        return [
                            createBaseVNode("h2", _hoisted_12, [
                                _cache[15] || (_cache[15] = createBaseVNode("i", {class: "i-ph:warning-duotone flex-none text-2rem text-orange"}, null, -1)),
                                createTextVNode(" 确认删除模型【" + toDisplayString((_a = unref(selectedModel)) == null ? void 0 : _a.modelName) + "】吗？ ", 1)
                            ]),
                            createBaseVNode("div", _hoisted_13, [
                                createVNode(_component_SimpleButton, {
                                    onClick: _cache[8] || (_cache[8] = ($event) => deleteVisible.value = false)
                                }, {
                                    default: withCtx(() => _cache[16] || (_cache[16] = [
                                        createTextVNode(" 取消 ")
                                    ])),
                                    _: 1
                                }),
                                createVNode(_component_SimpleButton, {
                                    type: "primary",
                                    onClick: confirmDelete
                                }, {
                                    default: withCtx(() => _cache[17] || (_cache[17] = [
                                        createTextVNode(" 确定 ")
                                    ])),
                                    _: 1
                                })
                            ])
                        ];
                    }),
                    _: 1
                }, 8, ["modelValue"])
            ]);
        };
    }
});
export {
    _sfc_main as default
};
